<?php
namespace Engine\Functions;
class parseAndConvert{
    public static function compressToList($array, $fieldName){
        $resultSet = array();

        foreach ($array as $key=>$value){
            if(is_array($value)){
                //ARRAY
                foreach($value as $keyIn=>$valueIn){
                    if ($keyIn==$fieldName){
                        $resultSet[]=$valueIn;
                    }
                }
            }
            else{
                if ($key==$fieldName){
                        $resultSet[]=$value;
                }
            }
        }

        return $resultSet?:false;

    }
    
    public static function isAnyElementItsArray($mixedToDo){
        foreach($mixedToDo as $value){
            if (!is_array($value)){
                return false;
            }
            return true;
        }
    }
     
    public static function keysHarvester($tepmlate, $mixedToDo, $keyName = 'complexTitle') {
        
        $prefixDelimeter = "^";
        $suffixDelimeter = "|";
        
        $resultSet = array();
        $tmpWork = array();
       
        
        //Преобразование в нужный для обработки формат (масси массивов, если даже элемент один)
        if (self::isAnyElementItsArray($mixedToDo)){
            $tmpWork = $mixedToDo;
        }else{
            $tmpWork[]=$mixedToDo;
        }
        //Парсим инф., необходимую для сбора
        foreach ($tepmlate as $oneTytle) {
            $key = array();
            $templateEl = explode("|", $oneTytle);
            
            print "<pre>";
            print_r($templateEl);
            print "</pre>";
            die("---");
            
                if (isset($templateEl) && count($templateEl == 2)){
                    $beforeSufPart = $templateEl[0];
                    $temporaryPreffix = \explode($prefixDelimeter, $beforeSufPart);

                }
        //Получаем
            $tmpKey['key'] = $templateEl[0];
            $key['key'] = $tmpKey['key'];
                
                if (strpos($tmpKey['key'], $suffixDelimeter)){
                }else{
                    
                }

                if (isset($templateEl[1])){$key['description'] = $templateEl[1];}

                $allKeysToDo[] = $key;
        }
        
        //Собираем
        foreach ($tmpWork as $key => $value) {
            $oneTytle = array();
            foreach ($allKeysToDo as $inKey) {
                if (isset($value[$inKey['key']])) {
                    $oneTytle []= $value[$inKey['key']].(count($inKey)>1?$inKey['description']:"");
                }
            }
            $resultSet[$key] = $oneTytle;
        }
        
        //Добавляем
        $preFinalResult = array();
        foreach($resultSet as $key => $result){
            $preFinalResult[$key]=implode(" ", $result);
        }
        
        foreach($tmpWork as $key=>$value){
            $tmp = $value;
            $tmp[$keyName] = $preFinalResult[$key];
            $resultSet[$key] = $tmp;
        }

        if (count($resultSet)==1){
            return end($resultSet);
        }
        
        return $resultSet;
    }
    
    /*
     * Функция разбирает строку $string по заданной маске $maskArray
     * Возвращает массив с результатами и заданными ключами $keysArray
     * Например:
     */
    
    public static function parseStringByMask($maskArray, $string){
        $notDelimeter = false;
        
        if (\is_string($string)){
            $resultSet = array();
            if (strlen($maskArray)==2){
                $prefSymb = $maskArray[0];
                $suffSymb = $maskArray[1];
            }else{
                $prefSymb = "|";
                $suffSymb = "^";
            }
            
            $preffix = mb_strstr($string, $prefSymb, true);
            $suffix = mb_strstr($string, $suffSymb, false);
            $suffix = mb_substr($suffix, 1);
            
            if (!mb_strpos($string, $prefSymb) && !strpos($string, $suffSymb)){
                if(mb_substr($string, \mb_strlen($string)-1, 1) == '%'){
                    $notDelimeter = true;
                    $key = substr($string, 0, strlen($string)-1);
                }else{
                    $notDelimeter = false;
                    $key = $string;
                }
            }else{
                $start = ($preffix?mb_strlen($preffix):0);
                $count = ($suffix?(mb_strlen($string)-mb_strlen($suffix)-($preffix?mb_strlen($preffix):0)):mb_strlen($string));
                $key = \mb_substr($string, $start+($preffix?1:0), $count-($suffix?1:0)-($preffix?1:0));
            }

            $resultSet['preffix'] = $preffix;
            $resultSet['key'] = $key;
            $resultSet['suffix'] = $suffix;
            $resultSet['notDelimeter'] = $notDelimeter;
            
            return $resultSet;
        }else{
            return false;
        }
        
    }
    
    public static function arrayValuesHarvester($template, $array, $keyForSave ='harvested') {
        $resultSet = array();
        
        foreach($array as $key=>$value){
            $temp = "";
            if (\array_key_exists($key, $template)){
                  $temp = $template[$key]['preffix'].$value.$template[$key]['suffix'];
            }
            $resultSet[]=$temp;
        }
        
        return $resultSet;
    } 

    
    
    public static function keysHarvester2($tepmlate, $mixedToDo, $delimeter=", ", $alternateDelimeter ='&bnsp;', $keyName = 'complexTitle'){
        
        //Читать из настроек в админке
        $preffixSymbol = "|";
        $suffixSymbol = "^";
        $signNoDelimeterAfterMe = "%";
        
        //Преобразование в нужный для обработки формат (масси массивов, если даже элемент один) $tmpWork
        if (self::isAnyElementItsArray($mixedToDo)){
            $tmpWork = $mixedToDo;
        }else{
            $tmpWork[]=$mixedToDo;
        }
        
        
        //Получаем ассоциативный массив с префиксами и суффиксами $resultArr
        $parseArr = array();
        foreach ($tepmlate as $oneTytle) {
            $temp = self::parseStringByMask($preffixSymbol.$suffixSymbol, $oneTytle);
            $parseArr[] = $temp;
            $resultArr[$temp['key']] = $temp;
        }
        $keysArray = array();
        foreach($tmpWork as $key=>$element){
            $keysArray[$key] = self::arrayValuesHarvester($resultArr, $element);
            
            $countKeys = count($keysArray[$key]);
            $counter = 0;
            
            $temp ="";
            foreach($resultArr as $inKey=>$value){
                $counter++;
                if (\key_exists($inKey, $element)){
                    $temp.=$value['preffix'].$element[$inKey].$value['suffix'].($countKeys!=$counter?$resultArr[$inKey]['notDelimeter']?$alternateDelimeter:$delimeter:"");
                }
            }
            $tmpWork[$key][$keyName] = $temp;
        }
        $resultSet = $tmpWork;
        return $resultSet;
    }
    
}
?>
